home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 301-325 / disk_309 / csh / comm1.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  17KB  |  794 lines
  1. /*
  2.  * COMM1.C
  3.  *
  4.  * Matthew Dillon, August 1986
  5.  *
  6.  * Version 2.07M by Steve Drew 10-Sep-87
  7.  *
  8.  * Version 4.00A by Carlo Borreo & Cesare Dieni 13-Jan-90
  9.  *
  10.  */
  11.  
  12. #define DIR_SHORT 0x01
  13. #define DIR_FILES 0x02
  14. #define DIR_DIRS  0x04
  15. #define DIR_NOCOL 0x08
  16. #define DIR_NAMES 0x10
  17.  
  18. extern int has_wild;
  19.  
  20. /*
  21.     Parse the options specified in sw[]
  22.     Setting a bit in global variable options
  23.     for each one found
  24. */
  25.  
  26. get_opt(sw,count)
  27. char *sw;
  28. int *count;
  29. {
  30. register char *c,*s;
  31. unsigned int l,i = 0;
  32.  
  33. options=0;
  34. while((++i < ac) && (av[i][0] == '-')) {
  35.     for (c = av[i]+1; *c ; c++) {
  36.         for(l = 0,s = sw;*s && *s != *c; ++s) ++l;
  37.         if (*s) options |= (1 << l);
  38.         }
  39.     }
  40. *count = i;
  41. }
  42.  
  43. do_sleep()
  44. {
  45. register int i;
  46.  
  47. if (ac == 2) for (i=atoi(av[1]); i>0 && !CHECKBREAK(); i-=2) Delay(100L);
  48. return 0;
  49. }
  50.  
  51. do_protect()
  52. {
  53. register long mask=0xf;
  54. register char *s, *p;
  55. static char flags[]="DEWRAPSH";
  56. register unsigned short i;
  57.  
  58. for (s=av[--ac]; *s; s++)
  59.     if (p=index(flags, toupper(*s))) mask^=(1 << (p-flags));
  60.     else ierror(av[ac],500);
  61. for (i=1; i<ac; i++) if (!SetProtection(av[i],mask)) pError(av[i]);
  62. return 0;
  63. }
  64.  
  65. do_filenote()
  66. {
  67. char *note=av[--ac];
  68. register unsigned int i;
  69.  
  70. for (i=1; i<ac; i++) if (!SetComment(av[i], note)) pError(av[i]);
  71. return 0;
  72. }
  73.  
  74. do_cat()
  75. {
  76. FILE *fopen(), *fi;
  77. register unsigned int lctr;
  78. unsigned int i;
  79. char buf[256];
  80.  
  81. get_opt("n",&i);
  82. if (i>=ac) {
  83.     if (has_wild) { printf("No files matching\n"); return 20; }
  84.     lctr=0;
  85.     while (gets(buf) && !dobreak()) {
  86.         if (options) printf("%4d ",++lctr);
  87.         puts(buf);
  88.         }
  89.     }
  90. for (; i<ac; i++)
  91.     if (fi = fopen (av[i], "r")) {
  92.         lctr=0;
  93.         while (fgets(buf,256,fi) && !dobreak()) {
  94.             if (options) printf("%4d ",++lctr);
  95.             printf("%s",buf);
  96.             }
  97.         fclose (fi);
  98.         }
  99.     else pError(av[i]);
  100. return 0;
  101. }
  102.  
  103. do_info()
  104. {
  105. BPTR lock;
  106. struct InfoData *info;
  107. long size, free;
  108. char *p, buf[130], *state;
  109. struct DirectoryEntry *de_head=NULL, *de;
  110.  
  111. info=(struct InfoData *)AllocMem((long)sizeof(struct InfoData),MEMF_PUBLIC);
  112. AddDADevs(&de_head, DLF_DEVICES | DLF_DISKONLY );
  113. Myprocess->pr_WindowPtr = (APTR)(-1);
  114. printf ("Unit  Size  Bytes  Used Blk/By-Free Full Errs  Status    Name\n");
  115. for (de=de_head; de; de=de->de_Next) {
  116.     printf("%-5s",de->de_Name);
  117.     if (lock=Lock(de->de_Name,ACCESS_READ)) {
  118.         if (Info(lock, info)) {
  119.         PathName(lock, buf, 128L);
  120.         if (p=index(buf,':')) *p = '\0';
  121.         size = ((info->id_NumBlocks + 2)* info->id_BytesPerBlock)/ 1024;
  122.         free = (((info->id_NumBlocks-info->id_NumBlocksUsed))*
  123.                info->id_BytesPerBlock)/ 1024;
  124.         switch(info->id_DiskState) {
  125.             case ID_WRITE_PROTECTED: state="Read Only "; break;
  126.             case ID_VALIDATED:     state="Read/Write"; break;
  127.             case ID_VALIDATING:     state="Validating"; break;
  128.             }
  129.         printf("%4ld%c%6ld%7ld%7ld%4ld%c%4ld%%%4ld  %s %s\n",
  130.             (size>1024) ? ((size+512) >> 10) : size,
  131.             (size>1024) ? 'M' : 'K',
  132.             info->id_BytesPerBlock,
  133.             info->id_NumBlocksUsed,
  134.             info->id_NumBlocks-info->id_NumBlocksUsed,
  135.             (free>1024) ? ((free+512) >> 10) : free,
  136.             (free>1024) ? 'M' : 'K',
  137.             (info->id_NumBlocksUsed * 100)/info->id_NumBlocks,
  138.             info->id_NumSoftErrors,
  139.             state,
  140.             buf);
  141.         }
  142.         else pError (de->de_Name);
  143.         UnLock(lock);
  144.         }
  145.     else puts("  No disk present");
  146.     }
  147. FreeDAList(&de_head);
  148. Myprocess->pr_WindowPtr = NULL;
  149. FreeMem(info,(long)sizeof(struct InfoData));
  150. return 0;
  151. }
  152.  
  153. /* things shared with display_file */
  154.  
  155. BPTR lastlock;
  156. int filecount, col;
  157. long bytes, blocks;
  158.  
  159. /*
  160.  * the args passed to do_dir will never be expanded
  161.  */
  162. do_dir()
  163. {
  164. int i, c, eac;
  165. char **eav;
  166.  
  167. col = filecount = 0;
  168. bytes = blocks = 0L;
  169. lastlock=NULL;
  170.  
  171. get_opt("sfdcn",&i);
  172.  
  173. if (ac == i) { ++ac; av[i]=""; }
  174. if (!(options & (DIR_FILES | DIR_DIRS))) options|=(DIR_FILES | DIR_DIRS);
  175.  
  176. for (; i<ac && !CHECKBREAK(); ++i)
  177.     if (eav = expand(av[i], &eac)) {
  178.         QuickSort(eav, eac);
  179.         for(c=0; c<eac && !CHECKBREAK(); ++c)
  180.             if (options & DIR_NAMES)
  181.                 puts(eav[c]);
  182.             else
  183.                 display_file(eav[c]);
  184.         free_expand (eav);
  185.         }
  186. if (col) printf("\n");
  187. if (filecount>1) {
  188.     blocks += filecount; /* account for dir blocks */
  189.     printf(" %ld Blocks, %ld Bytes used in %d files\n",
  190.         blocks, bytes, filecount);
  191.     }
  192. if (lastlock) UnLock(lastlock);
  193. return 0;
  194. }
  195.  
  196. display_file(filestr)
  197. char *filestr;
  198. {
  199. long atol();
  200. int isadir,slen;
  201. char sc, *fi, *base, buf[130];
  202. BPTR thislock;
  203.  
  204. base=BaseName(filestr);
  205. sc = *base;
  206. *base = '\0';
  207. thislock=Lock(filestr,SHARED_LOCK);
  208. /* if (thislock==NULL) return; */
  209. if (lastlock==NULL || CompareLock(thislock,lastlock)) {
  210.     if (col) printf("\n");
  211.     col = 0;
  212.     PathName(thislock, buf, 128L);
  213.     printf("Directory of %s\n", buf);
  214.     if (lastlock) UnLock(lastlock);
  215.     lastlock=thislock;
  216.     }
  217. else UnLock(thislock);
  218. *base = sc;
  219. slen = strlen(base);
  220. fi = base + slen + 1;
  221. isadir = (fi[12] =='D');
  222.  
  223. if (!(((options & DIR_FILES) && !isadir) ||
  224.     ((options & DIR_DIRS) &&  isadir)))
  225.         return;
  226. if (isadir && !(options & DIR_NOCOL)) printf ("\23333m");
  227. if (options & DIR_SHORT) {
  228.     if (col==3 && slen>18) { printf("\n"); col = 0; }
  229.     if (slen>18) { printf(" %-37s",base); col+= 2; }
  230.         else { printf(" %-18s",base); col++; }
  231.     if (col > 3) { printf("\n"); col=0; }
  232.     }
  233. else printf("   %-24s %s",base ,fi);
  234. if (isadir && !(options & DIR_NOCOL)) printf("\2330m");
  235. fi[16] = fi[21] = '\0';
  236. bytes  += atol(fi+10);
  237. blocks += atol(fi+17);
  238. filecount++;
  239. }
  240.  
  241. do_quit()
  242. {
  243. if (Src_stack) {
  244.     Quit = 1;
  245.     return(do_return());
  246.     }
  247. main_exit(0);
  248. }
  249.  
  250. do_echo()
  251. {
  252. int i;
  253.  
  254. get_opt("n",&i);
  255. for ( ; i<ac; i++) {
  256.     printf("%s", av[i]);
  257.     if (i != ac-1) printf(" ");
  258.     }
  259. if (!options) printf("\n");
  260. return 0;
  261. }
  262.  
  263. /* gets a line from file, joining two lines if the first ends in '\' */
  264.  
  265. char *myfgets(buf, buflen, file)
  266. char *buf;
  267. FILE *file;
  268. {
  269. char *bufptr=buf;
  270. int remain=buflen, n, flag;
  271.  
  272. do {
  273.     if (fgets(bufptr, remain, file)==NULL) {
  274.         if (remain != buflen)
  275.             fprintf(stderr,"Source: file ends in '\\'\n");
  276.         return NULL;
  277.         }
  278.     n=strlen(buf);
  279.     bufptr += n;
  280.     if (flag= (*(bufptr-2)=='\\')) bufptr-=2;
  281.     remain -= (n+2);
  282.     } while (flag);
  283. return buf;
  284. }
  285.  
  286. do_source(str)
  287. char *str;
  288. {
  289. register FILE *fi;
  290. char buf[256];
  291. int len;
  292.  
  293. if (Src_stack == MAXSRC) {
  294.     ierror(NULL,217);
  295.     return -1;
  296.     }
  297. if ((fi = fopen (av[1], "r")) == 0) { pError(av[1]); return -1;    }
  298. set_var(LEVEL_SET, v_passed, next_word(next_word(str)));
  299. ++H_stack;
  300. Src_pos[Src_stack] = 0;
  301. Src_base[Src_stack] = (long)fi;
  302. ++Src_stack;
  303. while (myfgets (buf, 256, fi) && !dobreak()) {
  304.     len = strlen(buf);
  305.     buf[len-1] = '\0';
  306.     Src_pos[Src_stack - 1] += len;
  307.     if (Verbose && !forward_goto) fprintf(stderr,"%s\n",buf);
  308.     exec_command (buf);
  309.     }
  310. --H_stack;
  311. --Src_stack;
  312. if (forward_goto) ierror(NULL,501);
  313. forward_goto = 0;
  314. unset_level(LEVEL_LABEL + Src_stack);
  315. unset_var(LEVEL_SET, v_gotofwd);
  316. unset_var(LEVEL_SET, v_passed);
  317. fclose (fi);
  318. return 0;
  319. }
  320.  
  321. /*
  322.  * set process cwd name and $_cwd, if str != NULL also print it.
  323.  */
  324. do_pwd(str)
  325. char *str;
  326. {
  327. char pwd[130];
  328.  
  329. PathName(Myprocess->pr_CurrentDir, pwd, 128L);
  330. if (str) puts(pwd);
  331. set_var(LEVEL_SET, v_cwd, pwd);
  332. /* put the current dir name in our CLI task structure */
  333. CtoBStr(pwd, Mycli->cli_SetName, 128L);
  334. return 0;
  335. }
  336.  
  337. /*
  338.  * CD
  339.  *
  340.  * CD(str, 0)      -do CD operation.
  341.  *
  342.  */
  343.  
  344. do_cd(str)
  345. char *str;
  346. {
  347. BPTR oldlock, filelock;
  348.  
  349. str=next_word(str);
  350. if (!strcmp("..",str)) str="/";
  351. filelock=Lock(str,ACCESS_READ);
  352. if (filelock==NULL) { pError(str); return 20; }
  353. if (!isdir(str)) { UnLock(filelock); ierror(str,212); return 20; }
  354. if (oldlock=CurrentDir(filelock)) UnLock(oldlock);
  355. do_pwd(NULL);
  356. return 0;
  357. }
  358.  
  359. do_mkdir()
  360. {
  361. register unsigned int i;
  362. BPTR lock;
  363.  
  364. for (i=1; i<ac; ++i) {
  365.     if (exists(av[i])) ierror(av[i],203);
  366.     else if (lock=CreateDir(av[i])) UnLock (lock);
  367.     else pError(av[i]);
  368.     }
  369. return 0;
  370. }
  371.  
  372. do_mv()
  373. {
  374. char *dest, buf[256];
  375. int dirflag;
  376. register unsigned int i;
  377.  
  378. dirflag=isdir(dest=av[--ac]);
  379. if (ac>3 && !dirflag) { ierror(dest, 507); return (-1); }
  380. for (i=1; i<ac; ++i) {
  381.     strcpy(buf, dest);
  382.     if (dirflag) TackOn(buf, BaseName(av[i]));
  383.     if (Rename(av[i], buf)==0)
  384.         { pError(av[i]); return -1; }
  385.     }
  386. return 0;
  387. }
  388.  
  389. int dirstoo;
  390.  
  391. all_args(args, action, dirsflag)
  392. char *args;
  393. int (*action)();
  394. {
  395. unsigned int i;
  396.  
  397. get_opt(args, &i);
  398. dirstoo=dirsflag;
  399. for (; i<ac && !dobreak(); ++i)
  400.     if (isdir(av[i])) {
  401.         if (options & 1) recurse(av[i], action);
  402.             else if (dirstoo) (*action)(av[i]);
  403.         }
  404.     else (*action)(av[i]);
  405. return 0;
  406. }
  407.  
  408. char *searchstring;
  409.  
  410. search_file(s)
  411. char *s;
  412. {
  413. FILE *fopen(), *fi;
  414. register char *p;
  415. register unsigned int
  416.     nocasedep, lctr, len, excl=((options & 16) !=0 ), yesno;
  417. char buf[256], lowbuf[256], searchit[256], first;
  418.  
  419. if (strcmp("STDIN",s)) fi=fopen(s,"r"); else fi=stdin;
  420. if (fi==NULL) { pError(s); return; }
  421. nocasedep=!(options & 2);
  422. lctr=0;
  423. if (!(options & 32)) printf("Examining %s...\n",s);
  424. strcpy(searchit,searchstring);
  425. if (options & 4) strcat(searchit,"\n");
  426. len=strlen(searchit);
  427. if (nocasedep) strupr(searchit);
  428. first=*searchit;
  429. while (fgets(buf,256,fi) && !dobreak()) {
  430.     lctr++;
  431.     if (options & 4) yesno=compare_ok(searchit, buf, options & 2);
  432.     else {
  433.         if (nocasedep) {
  434.             strcpy(lowbuf,buf);
  435.             strupr(lowbuf);
  436.             p=lowbuf;
  437.             }
  438.         else p=buf;
  439.         while ((p=index(p,first)) && strncmp(p++,searchit,len)) ;
  440.         yesno= (p!=NULL);
  441.         }
  442.     if (yesno ^ excl) {
  443.             /* default: print line numbers */
  444.         if (!(options & 8)) printf("%4d ",lctr);
  445.         printf("%s",buf);
  446.         }
  447.     }
  448. if (fi!=stdin) fclose (fi);
  449. }
  450.  
  451. do_search()
  452. {
  453. searchstring=av[--ac];
  454. all_args("rcwneq", search_file, 0);
  455. return 0;
  456. }
  457.  
  458. rm_file(file)
  459. char *file;
  460. {
  461. if (has_wild) printf(" %s...",file);
  462. if (options & 2) SetProtection(file,0L);
  463. if (!DeleteFile(file)) pError (file); else if (has_wild) printf("Deleted\n");
  464. }
  465.  
  466. do_rm()
  467. {
  468. all_args("rp", rm_file, 1);
  469. return 0;
  470. }
  471.  
  472. recurse(name, action)
  473. char *name;
  474. int (*action)();
  475. {
  476. register BPTR lock, cwd;
  477. register FIB *fib=(FIB *)AllocMem((long)sizeof(FIB),MEMF_PUBLIC);
  478. char *namecopy=malloc(256);
  479.  
  480. if (name[0] =='\0') return;
  481. namecopy[0]=0;
  482. if (lock=Lock(name,ACCESS_READ)) {
  483.     cwd =CurrentDir(lock);
  484.     if (Examine(lock, fib))
  485.     while (ExNext(lock, fib) && !CHECKBREAK()) {
  486.         if (*namecopy) { (*action)(namecopy); namecopy[0]=0; }
  487.         if (fib->fib_DirEntryType>=0) recurse(fib->fib_FileName,action);
  488.         else strcpy(namecopy,fib->fib_FileName);
  489.         }
  490.     if (*namecopy) (*action)(namecopy);
  491.     UnLock(CurrentDir(cwd));
  492.     if (dirstoo) (*action)(name);
  493.     }
  494. else pError(name);
  495. free(namecopy);
  496. FreeMem(fib, (long)sizeof(FIB));
  497. }
  498.  
  499. do_history()
  500. {
  501. register struct HIST *hist;
  502. int i = H_tail_base;
  503. int len = (av[1]) ? strlen(av[1]) : 0;
  504.  
  505. for (hist = H_tail; hist && !dobreak(); hist = hist->prev)
  506.     if (len == 0 || !strncmp(av[1], hist->line, len))
  507.         printf("%3d %s\n", i++, hist->line);
  508. return 0;
  509. }
  510.  
  511. do_mem()
  512. {
  513. long cfree, ffree;
  514. extern long AvailMem();
  515.  
  516. Forbid();
  517. cfree = AvailMem (MEMF_CHIP);
  518. ffree = AvailMem (MEMF_FAST);
  519. Permit();
  520. if (ffree) printf ("FAST memory: %ld\nCHIP memory: %ld\n", ffree, cfree);
  521. printf("Total  Free: %ld\n", cfree+ffree);
  522. return 0;
  523. }
  524.  
  525. do_forline()
  526. {
  527. char vname[33], buf[256];
  528. register unsigned short lctr;
  529. FILE *f;
  530. char *cstr;
  531.  
  532. strcpy(vname,av[1]);
  533. f=fopen(av[2],"r");
  534. if (f==NULL) pError(av[2]);
  535. lctr=0;
  536. ++H_stack;
  537. cstr = compile_av (av, 3, ac, ' ', 0);
  538. while (fgets(buf,256,f) && !dobreak()) {
  539.     buf[strlen(buf)-1]='\0';    /* remove CR */
  540.     lctr++;
  541.     set_var(LEVEL_SET, vname, buf);
  542.     sprintf(buf,"%d",lctr);
  543.     set_var(LEVEL_SET, v_linenum, buf);
  544.     exec_command(cstr);
  545.     }
  546. fclose(f);
  547. --H_stack;
  548. free (cstr);
  549. unset_var (LEVEL_SET, vname);
  550. unset_var (LEVEL_SET, v_linenum);
  551. return 0;
  552. }
  553.  
  554. do_fornum()
  555. {
  556. char vname[33], buf[16];
  557. int n1, n2, step, i, verbose;
  558. char *cstr;
  559.  
  560. get_opt("vs",&i);
  561. verbose=(options & 1);
  562. strcpy(vname,av[i++]);
  563. n1=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  564. n2=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  565. if (options & 2) {
  566.     step=myatoi(av[i++],-32767,32767); if (atoierr) return 20;
  567.     }
  568. else
  569.     step=1;
  570. ++H_stack;
  571. cstr = compile_av (av, i, ac, ' ', 0);
  572. for (i=n1; (step>=0 ? i<=n2 : i>=n2) && !CHECKBREAK(); i+=step) {
  573.     if (verbose) fprintf(stderr, "fornum: %d\n", i);
  574.     sprintf(buf,"%d",i);
  575.     set_var (LEVEL_SET, vname, buf);
  576.     exec_command(cstr);
  577.     }
  578. --H_stack;
  579. free (cstr);
  580. unset_var (LEVEL_SET, vname);
  581. return 0;
  582. }
  583.  
  584. /*
  585.  * foreach var_name  ( str str str str... str ) commands
  586.  * spacing is important (unfortunately)
  587.  *
  588.  * ac=0    1 2 3 4 5 6 7
  589.  * foreach i ( a b c ) echo $i
  590.  * foreach i ( *.c ) "echo -n "file ->";echo $i"
  591.  */
  592.  
  593. do_foreach()
  594. {
  595. register int cstart, cend;
  596. register char *cstr;
  597. char **fav;
  598. char vname[33];
  599. int i, verbose;
  600.  
  601. get_opt("v",&i);
  602. verbose=(options & 1);
  603. strcpy(vname, av[i++]);
  604. if (*av[i] == '(') i++;
  605. cstart = i;
  606. while (i<ac && *av[i] != ')') i++;
  607. if (i > ac) { fprintf(stderr,"')' expected\n"); return 20; }
  608. ++H_stack;
  609. cend = i;
  610.  
  611. fav = (char **)malloc(sizeof(char *) * (ac));
  612. cstr = compile_av (av, cend + 1, ac, ' ', 0);
  613.  
  614. for (i = cstart; i < cend; ++i) fav[i] = av[i];
  615.  
  616. for (i = cstart; i<cend && !CHECKBREAK(); ++i) {
  617.     set_var (LEVEL_SET, vname, fav[i]);
  618.     if (verbose) fprintf(stderr, "foreach: %s\n", fav[i]);
  619.     exec_command(cstr);
  620.     }
  621. --H_stack;
  622. free (fav);
  623. free (cstr);
  624. unset_var (LEVEL_SET, vname);
  625. return 0;
  626. }
  627.  
  628. do_forever(str)
  629. char *str;
  630. {
  631. int rcode = 0;
  632. char *ptr = next_word(str);
  633.  
  634. ++H_stack;
  635. for (;;) {
  636.     if (CHECKBREAK()) { rcode = 20; break; }
  637.     if (exec_command (ptr) < 0) {
  638.         str = get_var(LEVEL_SET, v_lasterr);
  639.         rcode = (str) ? atoi(str) : 20;
  640.         break;
  641.         }
  642.     }
  643. --H_stack;
  644. return rcode;
  645. }
  646.  
  647. do_exec(str)
  648. char *str;
  649. {
  650. return exec_command(next_word(str));
  651. }
  652.  
  653. extern struct Window *w;
  654. extern struct IntuitionBase *IntuitionBase;
  655.  
  656. do_window()
  657. {
  658. long x, y, maxwidth, maxheight, arg[5];
  659. unsigned int i;
  660. struct Screen *screen;
  661. struct Window *window;
  662.  
  663. get_opt("slfbaq", &i);
  664. if (options & 1)
  665.     SizeWindow(w, (long)(w->MinWidth-w->Width), (long)(w->MinHeight-w->Height));
  666. if (options & 2) {
  667.     x=-w->LeftEdge;
  668.     y=-w->TopEdge;
  669.     MoveWindow(w,x,y);
  670.     x=IntuitionBase->ActiveScreen->Width -w->Width;
  671.     y=IntuitionBase->ActiveScreen->Height-w->Height;
  672.     SizeWindow(w,x,y);
  673.     }
  674. if (options & 4) WindowToFront(w);
  675. if (options & 8) WindowToBack(w);
  676. if (options & 16) ActivateWindow(w);
  677. if(ac >= 5) {
  678.     for(i=1; i<5; i++) {
  679.         arg[i] = myatoi(av[i],0,1023); if (atoierr) return 20;
  680.         }
  681.     maxwidth = w->WScreen->Width;
  682.     maxheight= w->WScreen->Height;
  683.     if (arg[3] > maxwidth - arg[1] || arg[4] > maxheight- arg[2]) {
  684.         ierror(NULL, 500);
  685.         return 20;
  686.         }
  687.     x = -w->LeftEdge;
  688.     y = -w->TopEdge;
  689.     MoveWindow(w, x, y);
  690.     x = arg[3] - w->Width;
  691.     y = arg[4] - w->Height;
  692.     SizeWindow(w, x, y);
  693.     x = arg[1];
  694.     y = arg[2];
  695.     MoveWindow(w, x, y);
  696.     }
  697. if(options & 32) {
  698.     for (screen=IntuitionBase->FirstScreen; screen; screen=screen->NextScreen) {
  699.         printf("\nScreen \"%s\" (%d,%d,%dx%d):\n",
  700.             screen->Title,
  701.             screen->LeftEdge,
  702.             screen->TopEdge,
  703.             screen->Width,
  704.             screen->Height
  705.             );
  706.         for (window=screen->FirstWindow; window; window=window->NextWindow) {
  707.         printf("\tWindow\t\"%s\" (%d,%d,%dx%d)\n",
  708.             window->Title,
  709.             window->LeftEdge,
  710.             window->TopEdge,
  711.             window->Width,
  712.             window->Height
  713.             );
  714.         }
  715.         }
  716.     return 0;
  717.     }
  718. Delay(25L); /* pause 1/2 sec. before trying to print */
  719. printf("\014");
  720. return 0;
  721. }
  722.  
  723. setsystemtime(ds)
  724. struct DateStamp *ds;
  725. {
  726. struct timerequest tr;
  727. long secs= ds->ds_Days*86400 + ds->ds_Minute*60 + ds->ds_Tick/TICKS_PER_SECOND;
  728.  
  729. if (OpenDevice(TIMERNAME, UNIT_VBLANK, &tr, 0L)) {
  730.     fprintf(stderr,"Clock error: can't open timer device\n");
  731.     return;
  732.     }
  733. tr.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  734. tr.tr_node.io_Message.mn_Node.ln_Pri = 0L;
  735. tr.tr_node.io_Message.mn_Node.ln_Name = NULL;
  736. tr.tr_node.io_Message.mn_ReplyPort = NULL;
  737. tr.tr_node.io_Command = TR_SETSYSTIME;
  738. tr.tr_time.tv_secs = secs;
  739. tr.tr_time.tv_micro = 0L;
  740. if (DoIO (&tr)) fprintf(stderr,"Clock error: can't talk to timer device\n");
  741. CloseDevice (&tr);
  742. }
  743.  
  744. char tday[10];
  745.  
  746. char *dates(dss)
  747. struct DateStamp *dss;
  748. {
  749. static char timestr[40];
  750. char tdate[10], ttime[10];
  751. struct DateTime dt;
  752. struct DateStamp *myds=&(dt.dat_Stamp);
  753.  
  754. dt.dat_Format=FORMAT_DOS;
  755. dt.dat_StrDay=tday;
  756. dt.dat_StrDate=tdate;
  757. dt.dat_StrTime=ttime;
  758. dt.dat_Flags=NULL;
  759. myds->ds_Days=dss->ds_Days;
  760. myds->ds_Minute=dss->ds_Minute;
  761. myds->ds_Tick=dss->ds_Tick;
  762. StamptoStr(&dt);
  763. sprintf(timestr,"%s %s\n",tdate,ttime);
  764. timestr[18]='\n';
  765. timestr[19]='\0';    /* protection against bad timestamped files */
  766. return timestr;
  767. }
  768.  
  769. do_date()
  770. {
  771. struct DateStamp dss;
  772. register unsigned short i;
  773. struct DateTime dt;
  774.  
  775. dt.dat_Format=FORMAT_DOS;
  776. if (ac==1) {
  777.     DateStamp(&dss);
  778.     printf("%s %s",tday,dates(&dss));
  779.     }
  780. else {
  781.     DateStamp(& (dt.dat_Stamp));
  782.     for (i=1; i<ac; i++) {
  783.         dt.dat_StrDate=NULL;
  784.         dt.dat_StrTime=NULL;
  785.         dt.dat_Flags=DTF_FUTURE;
  786.         if (index(av[i],':')) dt.dat_StrTime=av[i];
  787.             else dt.dat_StrDate=av[i];
  788.         if (StrtoStamp(&dt)) ierror(av[i],500);
  789.         }
  790.     setsystemtime( & (dt.dat_Stamp) );
  791.     }
  792. return 0;
  793. }
  794.